//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS Budgets service.
///
/// Use the Amazon Web Services Budgets API to plan your service usage, service costs, and instance reservations. This API reference provides descriptions, syntax, and usage examples for each of the actions and data types for the Amazon Web Services Budgets feature.  Budgets provide you with a way to see the following information:   How close your plan is to your budgeted amount or to the free tier limits   Your usage-to-date, including how much you've used of your Reserved Instances (RIs)   Your current estimated charges from Amazon Web Services, and how much your predicted usage will accrue in charges by the end of the month   How much of your budget has been used   Amazon Web Services updates your budget status several times a day. Budgets track your unblended costs, subscriptions, refunds, and RIs. You can create the following types of budgets:    Cost budgets - Plan how much you want to spend on a service.    Usage budgets - Plan how much you want to use one or more services.    RI utilization budgets - Define a utilization threshold, and receive alerts when your RI usage falls below that threshold. This lets you see if your RIs are unused or under-utilized.    RI coverage budgets - Define a coverage threshold, and receive alerts when the number of your instance hours that are covered by RIs fall below that threshold. This lets you see how much of your instance usage is covered by a reservation.   Service Endpoint The Amazon Web Services Budgets API provides the following endpoint:   https://budgets.amazonaws.com   For information about costs that are associated with the Amazon Web Services Budgets API, see Amazon Web Services Cost Management Pricing.
public struct Budgets: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the Budgets client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: nil,
            partition: partition,
            amzTarget: "AWSBudgetServiceGateway",
            serviceName: "Budgets",
            serviceIdentifier: "budgets",
            serviceProtocol: .json(version: "1.1"),
            apiVersion: "2016-10-20",
            endpoint: endpoint,
            serviceEndpoints: Self.serviceEndpoints,
            partitionEndpoints: Self.partitionEndpoints,
            errorType: BudgetsErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }


    /// custom endpoints for regions
    static var serviceEndpoints: [String: String] {[
        "aws-cn-global": "budgets.amazonaws.com.cn",
        "aws-global": "budgets.amazonaws.com",
        "aws-iso-b-global": "budgets.global.sc2s.sgov.gov",
        "aws-iso-e-global": "budgets.global.cloud.adc-e.uk",
        "aws-iso-f-global": "budgets.global.csp.hci.ic.gov",
        "aws-iso-global": "budgets.c2s.ic.gov",
        "eu-isoe-west-1": "budgets.global.cloud.adc-e.uk",
        "us-iso-east-1": "budgets.c2s.ic.gov",
        "us-isob-east-1": "budgets.global.sc2s.sgov.gov",
        "us-isof-south-1": "budgets.global.csp.hci.ic.gov"
    ]}

    /// Default endpoint and region to use for each partition
    static var partitionEndpoints: [AWSPartition: (endpoint: String, region: SotoCore.Region)] {[
        .aws: (endpoint: "aws-global", region: .useast1),
        .awscn: (endpoint: "aws-cn-global", region: .cnnorthwest1),
        .awsiso: (endpoint: "aws-iso-global", region: .usisoeast1),
        .awsisob: (endpoint: "aws-iso-b-global", region: .usisobeast1),
        .awsisoe: (endpoint: "aws-iso-e-global", region: .euisoewest1),
        .awsisof: (endpoint: "aws-iso-f-global", region: .usisofsouth1)
    ]}


    // MARK: API Calls

    /// Creates a budget and, if included, notifications and subscribers.   Only one of BudgetLimit or PlannedBudgetLimits can be present in the syntax at one time. Use the syntax that matches your use case. The Request Syntax section shows the BudgetLimit syntax. For PlannedBudgetLimits, see the Examples section. Similarly, only one set of filter and metric selections can be present in the syntax at one time. Either FilterExpression and Metrics or CostFilters and CostTypes, not both or a different combination. We recommend using FilterExpression and Metrics as they provide more flexible and powerful filtering capabilities. The Request Syntax section shows the FilterExpression/Metrics syntax.
    @Sendable
    @inlinable
    public func createBudget(_ input: CreateBudgetRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateBudgetResponse {
        try await self.client.execute(
            operation: "CreateBudget", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a budget and, if included, notifications and subscribers.   Only one of BudgetLimit or PlannedBudgetLimits can be present in the syntax at one time. Use the syntax that matches your use case. The Request Syntax section shows the BudgetLimit syntax. For PlannedBudgetLimits, see the Examples section. Similarly, only one set of filter and metric selections can be present in the syntax at one time. Either FilterExpression and Metrics or CostFilters and CostTypes, not both or a different combination. We recommend using FilterExpression and Metrics as they provide more flexible and powerful filtering capabilities. The Request Syntax section shows the FilterExpression/Metrics syntax.
    ///
    /// Parameters:
    ///   - accountId: The accountId that is associated with the budget.
    ///   - budget: The budget object that you want to create.
    ///   - notificationsWithSubscribers: A notification that you want to associate with a budget. A budget can have up to five notifications, and each notification can have one SNS subscriber and up to 10 email subscribers. If you include notifications and subscribers in your CreateBudget call, Amazon Web Services creates the notifications and subscribers for you.
    ///   - resourceTags: An optional list of tags to associate with the specified budget. Each tag consists of a key and a value, and each key must be unique for the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createBudget(
        accountId: String,
        budget: Budget,
        notificationsWithSubscribers: [NotificationWithSubscribers]? = nil,
        resourceTags: [ResourceTag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateBudgetResponse {
        let input = CreateBudgetRequest(
            accountId: accountId, 
            budget: budget, 
            notificationsWithSubscribers: notificationsWithSubscribers, 
            resourceTags: resourceTags
        )
        return try await self.createBudget(input, logger: logger)
    }

    ///  Creates a budget action.
    @Sendable
    @inlinable
    public func createBudgetAction(_ input: CreateBudgetActionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateBudgetActionResponse {
        try await self.client.execute(
            operation: "CreateBudgetAction", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Creates a budget action.
    ///
    /// Parameters:
    ///   - accountId: 
    ///   - actionThreshold: 
    ///   - actionType:  The type of action. This defines the type of tasks that can be carried out by this action. This field also determines the format for definition.
    ///   - approvalModel:  This specifies if the action needs manual or automatic approval.
    ///   - budgetName: 
    ///   - definition: 
    ///   - executionRoleArn:  The role passed for action execution and reversion. Roles and actions must be in the same account.
    ///   - notificationType: 
    ///   - resourceTags: An optional list of tags to associate with the specified budget action. Each tag consists of a key and a value, and each key must be unique for the resource.
    ///   - subscribers: 
    ///   - logger: Logger use during operation
    @inlinable
    public func createBudgetAction(
        accountId: String,
        actionThreshold: ActionThreshold,
        actionType: ActionType,
        approvalModel: ApprovalModel,
        budgetName: String,
        definition: Definition,
        executionRoleArn: String,
        notificationType: NotificationType,
        resourceTags: [ResourceTag]? = nil,
        subscribers: [Subscriber],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateBudgetActionResponse {
        let input = CreateBudgetActionRequest(
            accountId: accountId, 
            actionThreshold: actionThreshold, 
            actionType: actionType, 
            approvalModel: approvalModel, 
            budgetName: budgetName, 
            definition: definition, 
            executionRoleArn: executionRoleArn, 
            notificationType: notificationType, 
            resourceTags: resourceTags, 
            subscribers: subscribers
        )
        return try await self.createBudgetAction(input, logger: logger)
    }

    /// Creates a notification. You must create the budget before you create the associated notification.
    @Sendable
    @inlinable
    public func createNotification(_ input: CreateNotificationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateNotificationResponse {
        try await self.client.execute(
            operation: "CreateNotification", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a notification. You must create the budget before you create the associated notification.
    ///
    /// Parameters:
    ///   - accountId: The accountId that is associated with the budget that you want to create a notification for.
    ///   - budgetName: The name of the budget that you want Amazon Web Services to notify you about. Budget names must be unique within an account.
    ///   - notification: The notification that you want to create.
    ///   - subscribers: A list of subscribers that you want to associate with the notification. Each notification can have one SNS subscriber and up to 10 email subscribers.
    ///   - logger: Logger use during operation
    @inlinable
    public func createNotification(
        accountId: String,
        budgetName: String,
        notification: Notification,
        subscribers: [Subscriber],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateNotificationResponse {
        let input = CreateNotificationRequest(
            accountId: accountId, 
            budgetName: budgetName, 
            notification: notification, 
            subscribers: subscribers
        )
        return try await self.createNotification(input, logger: logger)
    }

    /// Creates a subscriber. You must create the associated budget and notification before you create the subscriber.
    @Sendable
    @inlinable
    public func createSubscriber(_ input: CreateSubscriberRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateSubscriberResponse {
        try await self.client.execute(
            operation: "CreateSubscriber", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a subscriber. You must create the associated budget and notification before you create the subscriber.
    ///
    /// Parameters:
    ///   - accountId: The accountId that is associated with the budget that you want to create a subscriber for.
    ///   - budgetName: The name of the budget that you want to subscribe to. Budget names must be unique within an account.
    ///   - notification: The notification that you want to create a subscriber for.
    ///   - subscriber: The subscriber that you want to associate with a budget notification.
    ///   - logger: Logger use during operation
    @inlinable
    public func createSubscriber(
        accountId: String,
        budgetName: String,
        notification: Notification,
        subscriber: Subscriber,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateSubscriberResponse {
        let input = CreateSubscriberRequest(
            accountId: accountId, 
            budgetName: budgetName, 
            notification: notification, 
            subscriber: subscriber
        )
        return try await self.createSubscriber(input, logger: logger)
    }

    /// Deletes a budget. You can delete your budget at any time.  Deleting a budget also deletes the notifications and subscribers that are associated with that budget.
    @Sendable
    @inlinable
    public func deleteBudget(_ input: DeleteBudgetRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteBudgetResponse {
        try await self.client.execute(
            operation: "DeleteBudget", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a budget. You can delete your budget at any time.  Deleting a budget also deletes the notifications and subscribers that are associated with that budget.
    ///
    /// Parameters:
    ///   - accountId: The accountId that is associated with the budget that you want to delete.
    ///   - budgetName: The name of the budget that you want to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteBudget(
        accountId: String,
        budgetName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteBudgetResponse {
        let input = DeleteBudgetRequest(
            accountId: accountId, 
            budgetName: budgetName
        )
        return try await self.deleteBudget(input, logger: logger)
    }

    ///  Deletes a budget action.
    @Sendable
    @inlinable
    public func deleteBudgetAction(_ input: DeleteBudgetActionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteBudgetActionResponse {
        try await self.client.execute(
            operation: "DeleteBudgetAction", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Deletes a budget action.
    ///
    /// Parameters:
    ///   - accountId: 
    ///   - actionId:  A system-generated universally unique identifier (UUID) for the action.
    ///   - budgetName: 
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteBudgetAction(
        accountId: String,
        actionId: String,
        budgetName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteBudgetActionResponse {
        let input = DeleteBudgetActionRequest(
            accountId: accountId, 
            actionId: actionId, 
            budgetName: budgetName
        )
        return try await self.deleteBudgetAction(input, logger: logger)
    }

    /// Deletes a notification.  Deleting a notification also deletes the subscribers that are associated with the notification.
    @Sendable
    @inlinable
    public func deleteNotification(_ input: DeleteNotificationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteNotificationResponse {
        try await self.client.execute(
            operation: "DeleteNotification", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a notification.  Deleting a notification also deletes the subscribers that are associated with the notification.
    ///
    /// Parameters:
    ///   - accountId: The accountId that is associated with the budget whose notification you want to delete.
    ///   - budgetName: The name of the budget whose notification you want to delete.
    ///   - notification: The notification that you want to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteNotification(
        accountId: String,
        budgetName: String,
        notification: Notification,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteNotificationResponse {
        let input = DeleteNotificationRequest(
            accountId: accountId, 
            budgetName: budgetName, 
            notification: notification
        )
        return try await self.deleteNotification(input, logger: logger)
    }

    /// Deletes a subscriber.  Deleting the last subscriber to a notification also deletes the notification.
    @Sendable
    @inlinable
    public func deleteSubscriber(_ input: DeleteSubscriberRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteSubscriberResponse {
        try await self.client.execute(
            operation: "DeleteSubscriber", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a subscriber.  Deleting the last subscriber to a notification also deletes the notification.
    ///
    /// Parameters:
    ///   - accountId: The accountId that is associated with the budget whose subscriber you want to delete.
    ///   - budgetName: The name of the budget whose subscriber you want to delete.
    ///   - notification: The notification whose subscriber you want to delete.
    ///   - subscriber: The subscriber that you want to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteSubscriber(
        accountId: String,
        budgetName: String,
        notification: Notification,
        subscriber: Subscriber,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteSubscriberResponse {
        let input = DeleteSubscriberRequest(
            accountId: accountId, 
            budgetName: budgetName, 
            notification: notification, 
            subscriber: subscriber
        )
        return try await self.deleteSubscriber(input, logger: logger)
    }

    /// Describes a budget.  The Request Syntax section shows the BudgetLimit syntax. For PlannedBudgetLimits, see the Examples section.
    @Sendable
    @inlinable
    public func describeBudget(_ input: DescribeBudgetRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeBudgetResponse {
        try await self.client.execute(
            operation: "DescribeBudget", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes a budget.  The Request Syntax section shows the BudgetLimit syntax. For PlannedBudgetLimits, see the Examples section.
    ///
    /// Parameters:
    ///   - accountId: The accountId that is associated with the budget that you want a description of.
    ///   - budgetName: The name of the budget that you want a description of.
    ///   - showFilterExpression: Specifies whether the response includes the filter expression associated with the budget. By showing the filter expression, you can see detailed filtering logic applied to the budget, such as Amazon Web Services services or tags that are being tracked.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeBudget(
        accountId: String,
        budgetName: String,
        showFilterExpression: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeBudgetResponse {
        let input = DescribeBudgetRequest(
            accountId: accountId, 
            budgetName: budgetName, 
            showFilterExpression: showFilterExpression
        )
        return try await self.describeBudget(input, logger: logger)
    }

    ///  Describes a budget action detail.
    @Sendable
    @inlinable
    public func describeBudgetAction(_ input: DescribeBudgetActionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeBudgetActionResponse {
        try await self.client.execute(
            operation: "DescribeBudgetAction", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Describes a budget action detail.
    ///
    /// Parameters:
    ///   - accountId: 
    ///   - actionId:  A system-generated universally unique identifier (UUID) for the action.
    ///   - budgetName: 
    ///   - logger: Logger use during operation
    @inlinable
    public func describeBudgetAction(
        accountId: String,
        actionId: String,
        budgetName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeBudgetActionResponse {
        let input = DescribeBudgetActionRequest(
            accountId: accountId, 
            actionId: actionId, 
            budgetName: budgetName
        )
        return try await self.describeBudgetAction(input, logger: logger)
    }

    ///  Describes a budget action history detail.
    @Sendable
    @inlinable
    public func describeBudgetActionHistories(_ input: DescribeBudgetActionHistoriesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeBudgetActionHistoriesResponse {
        try await self.client.execute(
            operation: "DescribeBudgetActionHistories", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Describes a budget action history detail.
    ///
    /// Parameters:
    ///   - accountId: 
    ///   - actionId:  A system-generated universally unique identifier (UUID) for the action.
    ///   - budgetName: 
    ///   - maxResults: 
    ///   - nextToken: 
    ///   - timePeriod: 
    ///   - logger: Logger use during operation
    @inlinable
    public func describeBudgetActionHistories(
        accountId: String,
        actionId: String,
        budgetName: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        timePeriod: TimePeriod? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeBudgetActionHistoriesResponse {
        let input = DescribeBudgetActionHistoriesRequest(
            accountId: accountId, 
            actionId: actionId, 
            budgetName: budgetName, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            timePeriod: timePeriod
        )
        return try await self.describeBudgetActionHistories(input, logger: logger)
    }

    ///  Describes all of the budget actions for an account.
    @Sendable
    @inlinable
    public func describeBudgetActionsForAccount(_ input: DescribeBudgetActionsForAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeBudgetActionsForAccountResponse {
        try await self.client.execute(
            operation: "DescribeBudgetActionsForAccount", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Describes all of the budget actions for an account.
    ///
    /// Parameters:
    ///   - accountId: 
    ///   - maxResults: 
    ///   - nextToken: 
    ///   - logger: Logger use during operation
    @inlinable
    public func describeBudgetActionsForAccount(
        accountId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeBudgetActionsForAccountResponse {
        let input = DescribeBudgetActionsForAccountRequest(
            accountId: accountId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.describeBudgetActionsForAccount(input, logger: logger)
    }

    ///  Describes all of the budget actions for a budget.
    @Sendable
    @inlinable
    public func describeBudgetActionsForBudget(_ input: DescribeBudgetActionsForBudgetRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeBudgetActionsForBudgetResponse {
        try await self.client.execute(
            operation: "DescribeBudgetActionsForBudget", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Describes all of the budget actions for a budget.
    ///
    /// Parameters:
    ///   - accountId: 
    ///   - budgetName: 
    ///   - maxResults: 
    ///   - nextToken: 
    ///   - logger: Logger use during operation
    @inlinable
    public func describeBudgetActionsForBudget(
        accountId: String,
        budgetName: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeBudgetActionsForBudgetResponse {
        let input = DescribeBudgetActionsForBudgetRequest(
            accountId: accountId, 
            budgetName: budgetName, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.describeBudgetActionsForBudget(input, logger: logger)
    }

    ///  Lists the budget names and notifications that are associated with an account.
    @Sendable
    @inlinable
    public func describeBudgetNotificationsForAccount(_ input: DescribeBudgetNotificationsForAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeBudgetNotificationsForAccountResponse {
        try await self.client.execute(
            operation: "DescribeBudgetNotificationsForAccount", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Lists the budget names and notifications that are associated with an account.
    ///
    /// Parameters:
    ///   - accountId: 
    ///   - maxResults:  An integer that represents how many budgets a paginated response contains. The
    ///   - nextToken: 
    ///   - logger: Logger use during operation
    @inlinable
    public func describeBudgetNotificationsForAccount(
        accountId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeBudgetNotificationsForAccountResponse {
        let input = DescribeBudgetNotificationsForAccountRequest(
            accountId: accountId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.describeBudgetNotificationsForAccount(input, logger: logger)
    }

    /// Describes the history for DAILY, MONTHLY, and QUARTERLY budgets. Budget history isn't available for ANNUAL budgets.
    @Sendable
    @inlinable
    public func describeBudgetPerformanceHistory(_ input: DescribeBudgetPerformanceHistoryRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeBudgetPerformanceHistoryResponse {
        try await self.client.execute(
            operation: "DescribeBudgetPerformanceHistory", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes the history for DAILY, MONTHLY, and QUARTERLY budgets. Budget history isn't available for ANNUAL budgets.
    ///
    /// Parameters:
    ///   - accountId: 
    ///   - budgetName: 
    ///   - maxResults: 
    ///   - nextToken: 
    ///   - timePeriod: Retrieves how often the budget went into an ALARM state for the specified time period.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeBudgetPerformanceHistory(
        accountId: String,
        budgetName: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        timePeriod: TimePeriod? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeBudgetPerformanceHistoryResponse {
        let input = DescribeBudgetPerformanceHistoryRequest(
            accountId: accountId, 
            budgetName: budgetName, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            timePeriod: timePeriod
        )
        return try await self.describeBudgetPerformanceHistory(input, logger: logger)
    }

    /// Lists the budgets that are associated with an account.  The Request Syntax section shows the BudgetLimit syntax. For PlannedBudgetLimits, see the Examples section.
    @Sendable
    @inlinable
    public func describeBudgets(_ input: DescribeBudgetsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeBudgetsResponse {
        try await self.client.execute(
            operation: "DescribeBudgets", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the budgets that are associated with an account.  The Request Syntax section shows the BudgetLimit syntax. For PlannedBudgetLimits, see the Examples section.
    ///
    /// Parameters:
    ///   - accountId: The accountId that is associated with the budgets that you want to describe.
    ///   - maxResults: An integer that represents how many budgets a paginated response contains. The default is 100.
    ///   - nextToken: The pagination token that you include in your request to indicate the next set of results that you want to retrieve.
    ///   - showFilterExpression: Specifies whether the response includes the filter expression associated with the budgets. By showing the filter expression, you can see detailed filtering logic applied to the budgets, such as Amazon Web Services services or tags that are being tracked.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeBudgets(
        accountId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        showFilterExpression: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeBudgetsResponse {
        let input = DescribeBudgetsRequest(
            accountId: accountId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            showFilterExpression: showFilterExpression
        )
        return try await self.describeBudgets(input, logger: logger)
    }

    /// Lists the notifications that are associated with a budget.
    @Sendable
    @inlinable
    public func describeNotificationsForBudget(_ input: DescribeNotificationsForBudgetRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeNotificationsForBudgetResponse {
        try await self.client.execute(
            operation: "DescribeNotificationsForBudget", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the notifications that are associated with a budget.
    ///
    /// Parameters:
    ///   - accountId: The accountId that is associated with the budget whose notifications you want descriptions of.
    ///   - budgetName: The name of the budget whose notifications you want descriptions of.
    ///   - maxResults: An optional integer that represents how many entries a paginated response contains.
    ///   - nextToken: The pagination token that you include in your request to indicate the next set of results that you want to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeNotificationsForBudget(
        accountId: String,
        budgetName: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeNotificationsForBudgetResponse {
        let input = DescribeNotificationsForBudgetRequest(
            accountId: accountId, 
            budgetName: budgetName, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.describeNotificationsForBudget(input, logger: logger)
    }

    /// Lists the subscribers that are associated with a notification.
    @Sendable
    @inlinable
    public func describeSubscribersForNotification(_ input: DescribeSubscribersForNotificationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeSubscribersForNotificationResponse {
        try await self.client.execute(
            operation: "DescribeSubscribersForNotification", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the subscribers that are associated with a notification.
    ///
    /// Parameters:
    ///   - accountId: The accountId that is associated with the budget whose subscribers you want descriptions of.
    ///   - budgetName: The name of the budget whose subscribers you want descriptions of.
    ///   - maxResults: An optional integer that represents how many entries a paginated response contains.
    ///   - nextToken: The pagination token that you include in your request to indicate the next set of results that you want to retrieve.
    ///   - notification: The notification whose subscribers you want to list.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeSubscribersForNotification(
        accountId: String,
        budgetName: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        notification: Notification,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeSubscribersForNotificationResponse {
        let input = DescribeSubscribersForNotificationRequest(
            accountId: accountId, 
            budgetName: budgetName, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            notification: notification
        )
        return try await self.describeSubscribersForNotification(input, logger: logger)
    }

    ///  Executes a budget action.
    @Sendable
    @inlinable
    public func executeBudgetAction(_ input: ExecuteBudgetActionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ExecuteBudgetActionResponse {
        try await self.client.execute(
            operation: "ExecuteBudgetAction", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Executes a budget action.
    ///
    /// Parameters:
    ///   - accountId: 
    ///   - actionId:  A system-generated universally unique identifier (UUID) for the action.
    ///   - budgetName: 
    ///   - executionType:  The type of execution.
    ///   - logger: Logger use during operation
    @inlinable
    public func executeBudgetAction(
        accountId: String,
        actionId: String,
        budgetName: String,
        executionType: ExecutionType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ExecuteBudgetActionResponse {
        let input = ExecuteBudgetActionRequest(
            accountId: accountId, 
            actionId: actionId, 
            budgetName: budgetName, 
            executionType: executionType
        )
        return try await self.executeBudgetAction(input, logger: logger)
    }

    /// Lists tags associated with a budget or budget action resource.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists tags associated with a budget or budget action resource.
    ///
    /// Parameters:
    ///   - resourceARN: The unique identifier for the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceARN: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceARN: resourceARN
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Creates tags for a budget or budget action resource.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates tags for a budget or budget action resource.
    ///
    /// Parameters:
    ///   - resourceARN: The unique identifier for the resource.
    ///   - resourceTags: The tags associated with the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceARN: String,
        resourceTags: [ResourceTag],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceARN: resourceARN, 
            resourceTags: resourceTags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Deletes tags associated with a budget or budget action resource.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes tags associated with a budget or budget action resource.
    ///
    /// Parameters:
    ///   - resourceARN: The unique identifier for the resource.
    ///   - resourceTagKeys: The key that's associated with the tag.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceARN: String,
        resourceTagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceARN: resourceARN, 
            resourceTagKeys: resourceTagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Updates a budget. You can change every part of a budget except for the budgetName and the calculatedSpend. When you modify a budget, the calculatedSpend drops to zero until Amazon Web Services has new usage data to use for forecasting.  Only one of BudgetLimit or PlannedBudgetLimits can be present in the syntax at one time. Use the syntax that matches your case. The Request Syntax section shows the BudgetLimit syntax. For PlannedBudgetLimits, see the Examples section. Similarly, only one set of filter and metric selections can be present in the syntax at one time. Either FilterExpression and Metrics or CostFilters and CostTypes, not both or a different combination. We recommend using FilterExpression and Metrics as they provide more flexible and powerful filtering capabilities. The Request Syntax section shows the FilterExpression/Metrics syntax.
    @Sendable
    @inlinable
    public func updateBudget(_ input: UpdateBudgetRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateBudgetResponse {
        try await self.client.execute(
            operation: "UpdateBudget", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a budget. You can change every part of a budget except for the budgetName and the calculatedSpend. When you modify a budget, the calculatedSpend drops to zero until Amazon Web Services has new usage data to use for forecasting.  Only one of BudgetLimit or PlannedBudgetLimits can be present in the syntax at one time. Use the syntax that matches your case. The Request Syntax section shows the BudgetLimit syntax. For PlannedBudgetLimits, see the Examples section. Similarly, only one set of filter and metric selections can be present in the syntax at one time. Either FilterExpression and Metrics or CostFilters and CostTypes, not both or a different combination. We recommend using FilterExpression and Metrics as they provide more flexible and powerful filtering capabilities. The Request Syntax section shows the FilterExpression/Metrics syntax.
    ///
    /// Parameters:
    ///   - accountId: The accountId that is associated with the budget that you want to update.
    ///   - newBudget: The budget that you want to update your budget to.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateBudget(
        accountId: String,
        newBudget: Budget,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateBudgetResponse {
        let input = UpdateBudgetRequest(
            accountId: accountId, 
            newBudget: newBudget
        )
        return try await self.updateBudget(input, logger: logger)
    }

    ///  Updates a budget action.
    @Sendable
    @inlinable
    public func updateBudgetAction(_ input: UpdateBudgetActionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateBudgetActionResponse {
        try await self.client.execute(
            operation: "UpdateBudgetAction", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Updates a budget action.
    ///
    /// Parameters:
    ///   - accountId: 
    ///   - actionId:  A system-generated universally unique identifier (UUID) for the action.
    ///   - actionThreshold: 
    ///   - approvalModel:  This specifies if the action needs manual or automatic approval.
    ///   - budgetName: 
    ///   - definition: 
    ///   - executionRoleArn:  The role passed for action execution and reversion. Roles and actions must be in the same account.
    ///   - notificationType: 
    ///   - subscribers: 
    ///   - logger: Logger use during operation
    @inlinable
    public func updateBudgetAction(
        accountId: String,
        actionId: String,
        actionThreshold: ActionThreshold? = nil,
        approvalModel: ApprovalModel? = nil,
        budgetName: String,
        definition: Definition? = nil,
        executionRoleArn: String? = nil,
        notificationType: NotificationType? = nil,
        subscribers: [Subscriber]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateBudgetActionResponse {
        let input = UpdateBudgetActionRequest(
            accountId: accountId, 
            actionId: actionId, 
            actionThreshold: actionThreshold, 
            approvalModel: approvalModel, 
            budgetName: budgetName, 
            definition: definition, 
            executionRoleArn: executionRoleArn, 
            notificationType: notificationType, 
            subscribers: subscribers
        )
        return try await self.updateBudgetAction(input, logger: logger)
    }

    /// Updates a notification.
    @Sendable
    @inlinable
    public func updateNotification(_ input: UpdateNotificationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateNotificationResponse {
        try await self.client.execute(
            operation: "UpdateNotification", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a notification.
    ///
    /// Parameters:
    ///   - accountId: The accountId that is associated with the budget whose notification you want to update.
    ///   - budgetName: The name of the budget whose notification you want to update.
    ///   - newNotification: The updated notification to be associated with a budget.
    ///   - oldNotification: The previous notification that is associated with a budget.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateNotification(
        accountId: String,
        budgetName: String,
        newNotification: Notification,
        oldNotification: Notification,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateNotificationResponse {
        let input = UpdateNotificationRequest(
            accountId: accountId, 
            budgetName: budgetName, 
            newNotification: newNotification, 
            oldNotification: oldNotification
        )
        return try await self.updateNotification(input, logger: logger)
    }

    /// Updates a subscriber.
    @Sendable
    @inlinable
    public func updateSubscriber(_ input: UpdateSubscriberRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateSubscriberResponse {
        try await self.client.execute(
            operation: "UpdateSubscriber", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a subscriber.
    ///
    /// Parameters:
    ///   - accountId: The accountId that is associated with the budget whose subscriber you want to update.
    ///   - budgetName: The name of the budget whose subscriber you want to update.
    ///   - newSubscriber: The updated subscriber that is associated with a budget notification.
    ///   - notification: The notification whose subscriber you want to update.
    ///   - oldSubscriber: The previous subscriber that is associated with a budget notification.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateSubscriber(
        accountId: String,
        budgetName: String,
        newSubscriber: Subscriber,
        notification: Notification,
        oldSubscriber: Subscriber,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateSubscriberResponse {
        let input = UpdateSubscriberRequest(
            accountId: accountId, 
            budgetName: budgetName, 
            newSubscriber: newSubscriber, 
            notification: notification, 
            oldSubscriber: oldSubscriber
        )
        return try await self.updateSubscriber(input, logger: logger)
    }
}

extension Budgets {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: Budgets, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension Budgets {
    /// Return PaginatorSequence for operation ``describeBudgetActionHistories(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeBudgetActionHistoriesPaginator(
        _ input: DescribeBudgetActionHistoriesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeBudgetActionHistoriesRequest, DescribeBudgetActionHistoriesResponse> {
        return .init(
            input: input,
            command: self.describeBudgetActionHistories,
            inputKey: \DescribeBudgetActionHistoriesRequest.nextToken,
            outputKey: \DescribeBudgetActionHistoriesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeBudgetActionHistories(_:logger:)``.
    ///
    /// - Parameters:
    ///   - accountId: 
    ///   - actionId:  A system-generated universally unique identifier (UUID) for the action.
    ///   - budgetName: 
    ///   - maxResults: 
    ///   - timePeriod: 
    ///   - logger: Logger used for logging
    @inlinable
    public func describeBudgetActionHistoriesPaginator(
        accountId: String,
        actionId: String,
        budgetName: String,
        maxResults: Int? = nil,
        timePeriod: TimePeriod? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeBudgetActionHistoriesRequest, DescribeBudgetActionHistoriesResponse> {
        let input = DescribeBudgetActionHistoriesRequest(
            accountId: accountId, 
            actionId: actionId, 
            budgetName: budgetName, 
            maxResults: maxResults, 
            timePeriod: timePeriod
        )
        return self.describeBudgetActionHistoriesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeBudgetActionsForAccount(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeBudgetActionsForAccountPaginator(
        _ input: DescribeBudgetActionsForAccountRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeBudgetActionsForAccountRequest, DescribeBudgetActionsForAccountResponse> {
        return .init(
            input: input,
            command: self.describeBudgetActionsForAccount,
            inputKey: \DescribeBudgetActionsForAccountRequest.nextToken,
            outputKey: \DescribeBudgetActionsForAccountResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeBudgetActionsForAccount(_:logger:)``.
    ///
    /// - Parameters:
    ///   - accountId: 
    ///   - maxResults: 
    ///   - logger: Logger used for logging
    @inlinable
    public func describeBudgetActionsForAccountPaginator(
        accountId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeBudgetActionsForAccountRequest, DescribeBudgetActionsForAccountResponse> {
        let input = DescribeBudgetActionsForAccountRequest(
            accountId: accountId, 
            maxResults: maxResults
        )
        return self.describeBudgetActionsForAccountPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeBudgetActionsForBudget(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeBudgetActionsForBudgetPaginator(
        _ input: DescribeBudgetActionsForBudgetRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeBudgetActionsForBudgetRequest, DescribeBudgetActionsForBudgetResponse> {
        return .init(
            input: input,
            command: self.describeBudgetActionsForBudget,
            inputKey: \DescribeBudgetActionsForBudgetRequest.nextToken,
            outputKey: \DescribeBudgetActionsForBudgetResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeBudgetActionsForBudget(_:logger:)``.
    ///
    /// - Parameters:
    ///   - accountId: 
    ///   - budgetName: 
    ///   - maxResults: 
    ///   - logger: Logger used for logging
    @inlinable
    public func describeBudgetActionsForBudgetPaginator(
        accountId: String,
        budgetName: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeBudgetActionsForBudgetRequest, DescribeBudgetActionsForBudgetResponse> {
        let input = DescribeBudgetActionsForBudgetRequest(
            accountId: accountId, 
            budgetName: budgetName, 
            maxResults: maxResults
        )
        return self.describeBudgetActionsForBudgetPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeBudgetNotificationsForAccount(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeBudgetNotificationsForAccountPaginator(
        _ input: DescribeBudgetNotificationsForAccountRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeBudgetNotificationsForAccountRequest, DescribeBudgetNotificationsForAccountResponse> {
        return .init(
            input: input,
            command: self.describeBudgetNotificationsForAccount,
            inputKey: \DescribeBudgetNotificationsForAccountRequest.nextToken,
            outputKey: \DescribeBudgetNotificationsForAccountResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeBudgetNotificationsForAccount(_:logger:)``.
    ///
    /// - Parameters:
    ///   - accountId: 
    ///   - maxResults:  An integer that represents how many budgets a paginated response contains. The
    ///   - logger: Logger used for logging
    @inlinable
    public func describeBudgetNotificationsForAccountPaginator(
        accountId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeBudgetNotificationsForAccountRequest, DescribeBudgetNotificationsForAccountResponse> {
        let input = DescribeBudgetNotificationsForAccountRequest(
            accountId: accountId, 
            maxResults: maxResults
        )
        return self.describeBudgetNotificationsForAccountPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeBudgetPerformanceHistory(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeBudgetPerformanceHistoryPaginator(
        _ input: DescribeBudgetPerformanceHistoryRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeBudgetPerformanceHistoryRequest, DescribeBudgetPerformanceHistoryResponse> {
        return .init(
            input: input,
            command: self.describeBudgetPerformanceHistory,
            inputKey: \DescribeBudgetPerformanceHistoryRequest.nextToken,
            outputKey: \DescribeBudgetPerformanceHistoryResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeBudgetPerformanceHistory(_:logger:)``.
    ///
    /// - Parameters:
    ///   - accountId: 
    ///   - budgetName: 
    ///   - maxResults: 
    ///   - timePeriod: Retrieves how often the budget went into an ALARM state for the specified time period.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeBudgetPerformanceHistoryPaginator(
        accountId: String,
        budgetName: String,
        maxResults: Int? = nil,
        timePeriod: TimePeriod? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeBudgetPerformanceHistoryRequest, DescribeBudgetPerformanceHistoryResponse> {
        let input = DescribeBudgetPerformanceHistoryRequest(
            accountId: accountId, 
            budgetName: budgetName, 
            maxResults: maxResults, 
            timePeriod: timePeriod
        )
        return self.describeBudgetPerformanceHistoryPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeBudgets(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeBudgetsPaginator(
        _ input: DescribeBudgetsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeBudgetsRequest, DescribeBudgetsResponse> {
        return .init(
            input: input,
            command: self.describeBudgets,
            inputKey: \DescribeBudgetsRequest.nextToken,
            outputKey: \DescribeBudgetsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeBudgets(_:logger:)``.
    ///
    /// - Parameters:
    ///   - accountId: The accountId that is associated with the budgets that you want to describe.
    ///   - maxResults: An integer that represents how many budgets a paginated response contains. The default is 100.
    ///   - showFilterExpression: Specifies whether the response includes the filter expression associated with the budgets. By showing the filter expression, you can see detailed filtering logic applied to the budgets, such as Amazon Web Services services or tags that are being tracked.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeBudgetsPaginator(
        accountId: String,
        maxResults: Int? = nil,
        showFilterExpression: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeBudgetsRequest, DescribeBudgetsResponse> {
        let input = DescribeBudgetsRequest(
            accountId: accountId, 
            maxResults: maxResults, 
            showFilterExpression: showFilterExpression
        )
        return self.describeBudgetsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeNotificationsForBudget(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeNotificationsForBudgetPaginator(
        _ input: DescribeNotificationsForBudgetRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeNotificationsForBudgetRequest, DescribeNotificationsForBudgetResponse> {
        return .init(
            input: input,
            command: self.describeNotificationsForBudget,
            inputKey: \DescribeNotificationsForBudgetRequest.nextToken,
            outputKey: \DescribeNotificationsForBudgetResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeNotificationsForBudget(_:logger:)``.
    ///
    /// - Parameters:
    ///   - accountId: The accountId that is associated with the budget whose notifications you want descriptions of.
    ///   - budgetName: The name of the budget whose notifications you want descriptions of.
    ///   - maxResults: An optional integer that represents how many entries a paginated response contains.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeNotificationsForBudgetPaginator(
        accountId: String,
        budgetName: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeNotificationsForBudgetRequest, DescribeNotificationsForBudgetResponse> {
        let input = DescribeNotificationsForBudgetRequest(
            accountId: accountId, 
            budgetName: budgetName, 
            maxResults: maxResults
        )
        return self.describeNotificationsForBudgetPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeSubscribersForNotification(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeSubscribersForNotificationPaginator(
        _ input: DescribeSubscribersForNotificationRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeSubscribersForNotificationRequest, DescribeSubscribersForNotificationResponse> {
        return .init(
            input: input,
            command: self.describeSubscribersForNotification,
            inputKey: \DescribeSubscribersForNotificationRequest.nextToken,
            outputKey: \DescribeSubscribersForNotificationResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeSubscribersForNotification(_:logger:)``.
    ///
    /// - Parameters:
    ///   - accountId: The accountId that is associated with the budget whose subscribers you want descriptions of.
    ///   - budgetName: The name of the budget whose subscribers you want descriptions of.
    ///   - maxResults: An optional integer that represents how many entries a paginated response contains.
    ///   - notification: The notification whose subscribers you want to list.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeSubscribersForNotificationPaginator(
        accountId: String,
        budgetName: String,
        maxResults: Int? = nil,
        notification: Notification,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeSubscribersForNotificationRequest, DescribeSubscribersForNotificationResponse> {
        let input = DescribeSubscribersForNotificationRequest(
            accountId: accountId, 
            budgetName: budgetName, 
            maxResults: maxResults, 
            notification: notification
        )
        return self.describeSubscribersForNotificationPaginator(input, logger: logger)
    }
}

extension Budgets.DescribeBudgetActionHistoriesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Budgets.DescribeBudgetActionHistoriesRequest {
        return .init(
            accountId: self.accountId,
            actionId: self.actionId,
            budgetName: self.budgetName,
            maxResults: self.maxResults,
            nextToken: token,
            timePeriod: self.timePeriod
        )
    }
}

extension Budgets.DescribeBudgetActionsForAccountRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Budgets.DescribeBudgetActionsForAccountRequest {
        return .init(
            accountId: self.accountId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Budgets.DescribeBudgetActionsForBudgetRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Budgets.DescribeBudgetActionsForBudgetRequest {
        return .init(
            accountId: self.accountId,
            budgetName: self.budgetName,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Budgets.DescribeBudgetNotificationsForAccountRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Budgets.DescribeBudgetNotificationsForAccountRequest {
        return .init(
            accountId: self.accountId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Budgets.DescribeBudgetPerformanceHistoryRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Budgets.DescribeBudgetPerformanceHistoryRequest {
        return .init(
            accountId: self.accountId,
            budgetName: self.budgetName,
            maxResults: self.maxResults,
            nextToken: token,
            timePeriod: self.timePeriod
        )
    }
}

extension Budgets.DescribeBudgetsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Budgets.DescribeBudgetsRequest {
        return .init(
            accountId: self.accountId,
            maxResults: self.maxResults,
            nextToken: token,
            showFilterExpression: self.showFilterExpression
        )
    }
}

extension Budgets.DescribeNotificationsForBudgetRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Budgets.DescribeNotificationsForBudgetRequest {
        return .init(
            accountId: self.accountId,
            budgetName: self.budgetName,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Budgets.DescribeSubscribersForNotificationRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Budgets.DescribeSubscribersForNotificationRequest {
        return .init(
            accountId: self.accountId,
            budgetName: self.budgetName,
            maxResults: self.maxResults,
            nextToken: token,
            notification: self.notification
        )
    }
}
